/*
 * Segundo Projeto de O
 * Autores: Vitor 11/01291028 e Matheus 10/0115942
 *
 * Created on 5 de Setembro de 2012, 15:56
 */

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <String.h>
#define EXTENTAB ".csv"
#define EXTENIDX ".idx"
/*
 *
 */
int Menu();
void intersercaoM();
void intercalacao();
void menuReginal();
void intercaleI(char*, char*, int);
void engine_interI(char*,char*,char*);
void geraArquI(char*,char*, char*);
int pegaStringI(char*, char*, FILE*, int*);
void gera_index (char *NomeArquivo);
int existeExten(char *NomeArquivo);
void colocaExten(char *Nome,char *exten);
FILE* abreArquivo(char *nomeAquivo, char *tipoAbertura);
void removeExten (char *nome);
void ordenaIndex(char *nome);
void engine_index(FILE* table, FILE* index);
int compara(unsigned char* nome1,unsigned char* nome2);
void intercale(char*, char*, int);
void engine_inter(char*,char*,char*);
void geraArqu(char*,char*, char*);
int pegaString(char*, char*, FILE*, int*);
void filtre(char*, char*, char*);

int main()
{
    unsigned int opcao = 0;

    while(opcao != 4)
    {
        printf("\n");
        printf("Sistema de Box Office, UnB, versao Alpha 1.0\n");
        printf("1. Intersecao\n");
        printf("2. Intercalacao\n");
        printf("3. Filmes Regionais\n");
        printf("4. Sair\n");
        scanf("%u", &opcao);
        if (opcao == 1)
            intersercaoM();
        if (opcao == 2)
            intercalacao();
        if (opcao == 3)
            menuReginal();
    }

    return 0;

}

int Menu()
{

    unsigned int opcao = 0;

    do
    {
        printf("\n");
        printf("1. Brasil e Argentina\n");
        printf("2. Argentina e United Kingdom\n");
        printf("3. Brasil e United Kingdom\n");
        printf("4. Todos\n");
        printf("5. Voltar\n");
        scanf("%u", &opcao);
    }
    while (opcao < 1 && opcao > 4);

    return opcao;
}

void intersercaoM()
{
    char brasil[]= "brasil", argentina[]= "argentina", uk[] = "uk", dois[] = "1_brasil_argentina";
    unsigned int opt;


    opt = Menu();

    if(opt == 1)
        intercaleI(brasil, argentina, 0);
    if(opt == 2)
        intercaleI(argentina, uk, 0);
    if(opt == 3)
        intercaleI(brasil, uk, 0);
    if(opt == 4)
    {
        intercaleI(brasil, argentina, 0);
        intercaleI(dois, uk, 1);
    }

}

void intercalacao()
{
    char brasil[]= "brasil", argentina[]= "argentina", uk[] = "uk", dois[] = "2_brasil_argentina";
    int opt;

    opt = Menu();
    if(opt == 1)
        intercale(argentina, brasil, 0);
    if(opt == 2)
        intercale(argentina, uk, 0);
    if(opt == 3)
        intercale(brasil, uk, 0);
    if(opt == 4)
    {
        intercale(brasil, argentina, 0);
        intercale(dois, uk, 1);
    }

}

void menuReginal()
{
    unsigned int opt = 0;
    char brasil[]= "brasil", argentina[]= "argentina", uk[] = "uk", nome[] = "1_brasil_uk", nome2[] = "lixo";
    FILE *lixo;

    do
    {
        printf("1. Brasil\n");
        printf("2. Argentina\n");
        printf("3. Brasil United Kingdom\n");
        scanf("%u", &opt);
    }
    while (opt < 1 && opt > 3);

    if(opt == 1)
        filtre(brasil , argentina, uk);
    if(opt == 2)
        filtre(argentina, brasil, uk);
    if(opt == 3)
    {
        lixo = fopen("lixo.csv", "w+");
        fclose(lixo);

        intercaleI(brasil, uk, 0);

        filtre(nome, argentina, nome2);
    }
}

void gera_index(char *nomeArquivo)
{
    int exiExt;
    char nomeArq[100], exten[] = EXTENTAB;
    char tipoAbert[4] = "r";
    FILE *index = NULL, *table = NULL;

    strcpy(nomeArq, nomeArquivo);

    //Abrindo o Arquivo CSV
    exiExt = existeExten(nomeArquivo);
    if (exiExt == 0)
    {
        colocaExten(nomeArq, exten);
        table = abreArquivo(nomeArq, tipoAbert);
        if (table == NULL)
        {
            printf("Erro de Arquivos");
            exit(1);
        }
    }
    else
    {
        table = abreArquivo(nomeArq, tipoAbert);
        if (table == NULL)
        {
            printf("Erro de Arquivos");
            exit(1);
        }
    }


    //Abrindo o Arquivo IDX
    strcpy(exten, EXTENIDX);
    strcpy(tipoAbert, "w+");

    removeExten(nomeArq);
    colocaExten(nomeArq, exten);

    index = abreArquivo(nomeArq, tipoAbert);
    if (index == NULL)
    {
        printf("Erro de Arquivos");
        exit(1);
    }

    //gerando o Index
    engine_index(table, index);

    //Fechando os Arquivos
    fclose(index);
    fclose(table);

    //Ordenado o Index
    ordenaIndex(nomeArq);
}

void engine_index(FILE* table, FILE* index)
{

    int prr = 0, i = 0;
    char lixo, nome[100];

    /*Cria o arquivo de indices com o tamanho do registro*/
    while (1)
    {
        //pegando o nome
        i = -1;
        do
        {
            i++;
            fscanf(table, "%c", &nome[i]);

            if (feof(table))
                break;
        }
        while (nome[i] != ';');
        if (feof(table))
            break;
        nome[i] = '\0';

        //gravando no index
        fprintf(index, "%s;%d\n", nome, prr);

        prr += i + 1;

        do
        {
            fscanf(table, "%c", &lixo);
            prr++;
        }
        while (lixo != '\n');
        prr++;

    }

}

int existeExten(char* nome)
{
    int i, k;

    for (i = 0, k = 0; nome[i] != '\0'; i++)
        if (nome[i] == '.')
            k++;

    return k;
}

void removeExten(char* nome)
{
    int i, k;

    for (i = 0, k = 0; nome[i] != '\0'; i++)
        if (nome[i] == '.')
            k = i;

    nome[k] = '\0';
}

void colocaExten(char* nome, char *exten)
{
    int i, k;

    for (i = 0, k = 0; exten[k] != '\0'; i++)
        if (nome[i] == '\0' || k != 0)
        {
            nome[i] = exten[k];
            k++;
        }

    nome[i] = '\0';
}

FILE* abreArquivo(char *nomeArquivo, char *tipoAbertura)
{
    FILE *arqui = NULL;
    arqui = fopen(nomeArquivo, tipoAbertura);
    return arqui;
}

void ordenaIndex(char* nome)
{
    FILE *index = NULL;
    int control = 1000000, i = 0, firstPass = 0;
    int organ = 1;
    char nome1[200], nome2[100], abre[] = "r+", lixo;
    int pulo = 0;

    index = abreArquivo(nome, abre);
    if (index == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    while (i < control && organ != 0)
    {
        organ = 0;
        rewind(index);

        while (!feof(index))
        {
            //pegando strings
            fscanf(index, "%[^\n]", nome1);
            if (feof(index))
                break;

            fscanf(index, "%c", &lixo);
            if (feof(index))
                break;

            fscanf(index, "%[^\n]", nome2);
            if (feof(index))
                break;

            //verificando se e necessaria a troca
            if (compara(nome1, nome2) > 0)
            {
                //trocando de posicao
                pulo = strlen(nome1) + strlen(nome2) + 2;
                fseek(index, -pulo, SEEK_CUR);

                fprintf(index, "%s\n%s", nome2, nome1);
                fseek(index, -strlen(nome1), SEEK_CUR);

                //fazendo controles
                organ++;
            }
            else
            {
                fseek(index, -strlen(nome2), SEEK_CUR);
            }

            if (firstPass == 0)
                control++;
        }
        if (firstPass == 0)
            control -= 1000000 - 1;
        firstPass++;

        i++;
    }

    fclose(index);
}

int compara(unsigned char* nome1,unsigned char* nome2)
{
    int diff = 0, i = 0;

    while (diff == 0 && nome1[i] != '\0' && nome2[i] != '\0')
    {
        diff += (int)(nome1[i]) - (int)(nome2[i]);
        i++;
    }
    return diff;
}

void engine_interI(char *nome1Arqu, char *nome2Arqu, char *nomeF)
{
    //variveis
    char reg1[200], reg2[200], prr1[10], prr2[10], ultima[200] = "ZZZZZZZZZZZ";
    unsigned short int control = 0, tag1 = 0, tag2 = 0;
    int greg1, greg2;
    FILE *index1 = NULL, *index2 = NULL, *indexF = NULL;
    ultima[0] = 255;

    //abrindos os arquivos
    index1 = abreArquivo(nome1Arqu, "r");
    if (index1 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index2 = abreArquivo(nome2Arqu, "r");
    if (index2 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    indexF = abreArquivo(nomeF, "w+");
    if (indexF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }



    //varrendo os index
    while (!(tag1 == 1 && tag2 == 1))
    {
        //pegando termos do arquvi 1
        if (control == 1 || control == 0)
        {
            tag1 = pegaStringI(reg1, prr1, index1, &greg1);
            if (tag1 == 1)
                strcpy(reg1, ultima);
        }

        if (control == 2 || control == 0)
        {
            tag2 = pegaStringI(reg2, prr2, index2, &greg2);
            if (tag2 == 1)
                strcpy(reg2, ultima);
        }

        //gravou tudo para
        if (tag1 == 1 && tag2 == 1)
            break;

        //fazendo o merge
        //cose iqual
        if (!strcmp(reg1, reg2))
        {
            fprintf(indexF, "%s;%s;1\n", reg1, prr1);
            control = 0;
            greg1 = 1;
            greg2 = 1;
        }
        else
        {
            //se nao iqual
            if (compara(reg1, reg2) < 0)
            {
                //fprintf(indexF, "%s;%s;1\n", reg1, prr1);
                control = 1;
            }
            else
            {
                //fprintf(indexF, "%s;%s;2\n", reg2, prr2);
                control = 2;
            }
        }
    }

    fclose(index1);
    fclose(index2);
    fclose(indexF);
}


void intercaleI(char *nome1Arqu, char *nome2Arqu, int nomeCaso4)
{
    char nome1[100], nome2[100], exten[] = EXTENIDX;
    char nomeF[200];

    strcpy(nome1, nome1Arqu);
    strcpy(nome2, nome2Arqu);

    //gerando os index
    gera_index(nome1Arqu);
    gera_index(nome2Arqu);

    //gerando o nome do arqui final
    if(nomeCaso4 == 1)
    {
        strcpy(nomeF, "1_argentina_brasil_uk.idx");
    }
    else
    {
    strcpy(nomeF, "1_");
    strcat(nomeF, nome1);
    strcat(nomeF, "_");
    strcat(nomeF, nome2);
    strcat(nomeF, ".idx");
    }
    //gerando os nomes dos arquis
    colocaExten(nome1, exten);
    colocaExten(nome2, exten);

    engine_interI(nome1, nome2, nomeF);
    geraArquI(nome1, nome2, nomeF);
}


int pegaStringI(char* registro, char* prr, FILE* index, int *valor)
{
    int i;
    if (feof(index))
        return 1;
    else
    {
        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &registro[i]);
            if (feof(index))
                return 1;
        }
        while (registro[i] != ';');
        registro[i] = '\0';

        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &prr[i]);
            if (feof(index))
                return 1;
        }
        while (prr[i] != '\n');
        prr[i] = '\0';
    }
    *valor = 0;
    return 0;
}

void geraArquI(char *nome1Arqu, char *nome2Arqu, char *nomeF)
{
    //variveis
    char reg[100], termo[100], lixo, exten[] = EXTENTAB;
    int prr, arqu;
    FILE *table1, *table2, *indexF, *tableF;

    //abrindos os arquivos
    removeExten(nome1Arqu);
    colocaExten(nome1Arqu, exten);
    table1 = abreArquivo(nome1Arqu, "r");
    if (table1 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    removeExten(nome2Arqu);
    colocaExten(nome2Arqu, exten);
    table2 = abreArquivo(nome2Arqu, "r");
    if (table2 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    indexF = abreArquivo(nomeF, "r");
    if (indexF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    removeExten(nomeF);
    colocaExten(nomeF, exten);
    tableF = abreArquivo(nomeF, "w+");
    if (tableF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    while (!feof(indexF))
    {
        fscanf(indexF, "%[^;]", termo);
        if (feof(indexF))
            break;

        fscanf(indexF, "%c", &lixo);
        fscanf(indexF, "%d", &prr);
        fscanf(indexF, "%c", &lixo);
        fscanf(indexF, "%d", &arqu);
        fscanf(indexF, "%c", &lixo);

        if (arqu == 1)
        {
            fseek(table1, prr, SEEK_SET);
            fscanf(table1, "%[^\n]", reg);
        }
        else
        {
            fseek(table2, prr, SEEK_SET);
            fscanf(table2, "%[^\n]", reg);
        }

        fprintf(tableF, "%s\n", reg);
    }
    fclose(table1);
    fclose(table2);
    fclose(indexF);
    fclose(tableF);

}

void intercale(char *nome1Arqu, char *nome2Arqu, int nomeCaso4)
{
    char nome1[100], nome2[100], exten[] = EXTENIDX;
    char nomeF[200];

    strcpy(nome1, nome1Arqu);
    strcpy(nome2, nome2Arqu);

    //gerando os index
    gera_index(nome1Arqu);
    gera_index(nome2Arqu);

    //gerando o nome do arqui final
    if(nomeCaso4 == 1)
    {
        strcpy(nomeF, "2_argentina_brasil_uk.idx");
    }
    else
    {
    strcpy(nomeF, "2_");
    strcat(nomeF, nome1);
    strcat(nomeF, "_");
    strcat(nomeF, nome2);
    strcat(nomeF, ".idx");
    }

    //gerando os nomes dos arquis
    colocaExten(nome1, exten);
    colocaExten(nome2, exten);

    engine_inter(nome1, nome2, nomeF);
    geraArqu(nome1, nome2, nomeF);
}

void engine_inter(char *nome1Arqu, char *nome2Arqu, char *nomeF)
{
    //variveis
    char reg1[200], reg2[200], prr1[10], prr2[10], ultima[200] = "ZZZZZZZZZZZ";
    unsigned short int control = 0, tag1 = 0, tag2 = 0;
    int greg1, greg2;
    FILE *index1 = NULL, *index2 = NULL, *indexF = NULL;
    ultima[0] = 255;

    //abrindos os arquivos
    index1 = abreArquivo(nome1Arqu, "r");
    if (index1 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index2 = abreArquivo(nome2Arqu, "r");
    if (index2 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    indexF = abreArquivo(nomeF, "w+");
    if (indexF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    //varrendo os index
    while (!(tag1 == 1 && tag2 == 1))
    {
        //pegando termos do arquvi 1
        if (control == 1 || control == 0)
        {
            tag1 = pegaString(reg1, prr1, index1, &greg1);
            if (tag1 == 1)
                strcpy(reg1, ultima);
        }

        if (control == 2 || control == 0)
        {
            tag2 = pegaString(reg2, prr2, index2, &greg2);
            if (tag2 == 1)
                strcpy(reg2, ultima);
        }

        //gravou tudo para
        if (tag1 == 1 && tag2 == 1)
            break;

        //fazendo o merge
        //cose iqual
        if (!strcmp(reg1, reg2))
        {
            fprintf(indexF, "%s;%s;1\n", reg1, prr1);
            control = 0;
            greg1 = 1;
            greg2 = 1;
        }
        else
        {
            //se nao iqual
            if (compara(reg1, reg2) < 0)
            {
                fprintf(indexF, "%s;%s;1\n", reg1, prr1);
                control = 1;
            }
            else
            {
                fprintf(indexF, "%s;%s;2\n", reg2, prr2);
                control = 2;
            }
        }
    }

    fclose(index1);
    fclose(index2);
    fclose(indexF);
}

int pegaString(char* registro, char* prr, FILE* index, int *valor)
{
    int i;
    if (feof(index))
        return 1;
    else
    {
        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &registro[i]);
            if (feof(index))
                return 1;
        }
        while (registro[i] != ';');
        registro[i] = '\0';

        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &prr[i]);
            if (feof(index))
                return 1;
        }
        while (prr[i] != '\n');
        prr[i] = '\0';
    }
    *valor = 0;
    return 0;
}

void geraArqu(char *nome1Arqu, char *nome2Arqu, char *nomeF)
{
    //variveis
    char reg[100], termo[100], lixo, exten[] = EXTENTAB;
    int prr, arqu;
    FILE *table1, *table2, *indexF, *tableF;

    //abrindos os arquivos
    removeExten(nome1Arqu);
    colocaExten(nome1Arqu, exten);
    table1 = abreArquivo(nome1Arqu, "r");
    if (table1 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    removeExten(nome2Arqu);
    colocaExten(nome2Arqu, exten);
    table2 = abreArquivo(nome2Arqu, "r");
    if (table2 == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    indexF = abreArquivo(nomeF, "r");
    if (indexF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    removeExten(nomeF);
    colocaExten(nomeF, exten);
    tableF = abreArquivo(nomeF, "w+");
    if (tableF == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    while (!feof(indexF))
    {
        fscanf(indexF, "%[^;]", termo);
        if (feof(indexF))
            break;

        fscanf(indexF, "%c", &lixo);
        fscanf(indexF, "%d", &prr);
        fscanf(indexF, "%c", &lixo);
        fscanf(indexF, "%d", &arqu);
        fscanf(indexF, "%c", &lixo);

        if (arqu == 1)
        {
            fseek(table1, prr, SEEK_SET);
            fscanf(table1, "%[^\n]", reg);
        }
        else
        {
            fseek(table2, prr, SEEK_SET);
            fscanf(table2, "%[^\n]", reg);
        }

        fprintf(tableF, "%s\n", reg);
    }
    fclose(table1);
    fclose(table2);
    fclose(indexF);
    fclose(tableF);

}

void engine_interIM(char *nome1Arqu, char *nome2Arqu, char *nome3Arqu, char *nomeF)
{
    //variveis
    char reg[3][200], prr[3][20], TermF[200];
    char regGR[200], regEOF[200], prrFI[20];
    int tagEOF[3], tagGRA[3] = {1 , 1, 1}, sTags = 0, i = 0, nIgual = 0, k = 0, l, diff;

    FILE * index[3], *indexF;

    for (i = 0; i < 200; i++)
        regEOF[i] = 255;
    index[0] = NULL;
    index[1] = NULL;
    index[2] = NULL;

    //abrindos os arquivos
    index[0] = abreArquivo(nome1Arqu, "r");
    if (index[0] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index[1] = abreArquivo(nome2Arqu, "r");
    if (index[1] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index[2] = abreArquivo(nome3Arqu, "r");
    if (index[2] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    indexF = abreArquivo(nomeF, "w+");
    if (index[2] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    for (i = 0; i < 3; i++)
    {
        tagEOF[i] = pegaStringIM(reg[i], prr[i], index[i], &l);
        if (tagEOF[i] == 1)
        {
            strcpy(reg[i], regEOF);
            sTags++;
        }
    }

    //varrendo os index
    while (sTags < 3)
    {
        k = 0;
        for (i = 1; i < 3; i++)
        {
            diff = compara(reg[k], reg[i]);
            if (diff > 0)
                k = i;
        }

        if (k == 0)
        {
            strcpy(TermF, reg[k]);
            strcpy(prrFI, prr[0]);
            tagGRA[0] = 0;
        }

        nIgual = 0;
        strcpy(regGR, reg[k]);

        for (i = 0; i < 3; i++)
        {
            if (!strcmp(reg[i], regGR))
            {
                nIgual++;
                tagEOF[i] = pegaStringIM(reg[i], prr[i], index[i], &l);
                if (tagEOF[i] == 1)
                {
                    strcpy(reg[i], regEOF);
                    sTags++;
                }
            }
        }

        if (nIgual != 1)
            tagGRA[0] = 1;

        if (tagGRA[0] == 0)
        {
            fprintf(indexF, "%s;%s\n", TermF, prrFI);
            tagGRA[0] = 1;
        }

    }

    fclose(index[0]);
    fclose(index[1]);
    fclose(index[2]);
    fclose(indexF);

}

void geraArquIM(char *nome, char *nomTab)
{
    //variveis
    char reg[100], termo[100], lixo, exten[] = EXTENTAB;
    char nomeTab[100];
    int prr, arqu;
    FILE *table, *index, *tableC;

    strcpy(nomeTab, nomTab);
    removeExten(nomeTab);
    colocaExten(nomeTab, exten);
    //abrindos os arquivos
    tableC = abreArquivo(nomeTab, "r");
    if (tableC == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    //abrindos os arquivos gerados
    index = abreArquivo(nome, "r");
    if (table == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    removeExten(nome);
    colocaExten(nome, exten);
    table = abreArquivo(nome, "w+");
    if (table == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    //transformando o index em um novo arquivo
    while (!feof(index))
    {
        fscanf(index, "%[^;]", termo);
        if (feof(index))
            break;

        fscanf(index, "%c", &lixo);
        fscanf(index, "%d", &prr);
        fscanf(index, "%c", &lixo);

        fseek(tableC, prr, SEEK_SET);
        fscanf(tableC, "%[^\n]", reg);

        fprintf(table, "%s\n", reg);
    }

    //fechando os arquivos
    fclose(tableC);
    fclose(table);
    fclose(index);

}

void filtre(char *paisP, char *nome2Arqu, char* nome3Arqu)
{
    char pais[100], nome2[100], exten[] = EXTENIDX;
    char nomeF[200], nome3[100];

    strcpy(pais, paisP);
    strcpy(nome2, nome2Arqu);
    strcpy(nome3, nome3Arqu);

    //gerando os index
    gera_index(pais);
    gera_index(nome2);
    gera_index(nome3);

    //gerando o nome do arqui final
    strcpy(nomeF, "3_");
    strcat(nomeF, pais);
    strcat(nomeF, ".aux");

    //gerando os nomes dos arquis
    colocaExten(pais, exten);
    colocaExten(nome2, exten);
    colocaExten(nome3, exten);

    engine_interIM(pais, nome2, nome3, nomeF);

    geraArquIM(nomeF, pais);
    //printf("porra");
}

int trataFimArquiIM(int greg, int tag, char* reg1, char* prr1, FILE* index1, FILE* indexF, char* reg2, int p)
{
    int tag1 = tag, greg1 = greg;

    while (tag1 != 1)
    {
        if (!strcmp(reg1, reg2))
        {
            tag1 = pegaString(reg1, prr1, index1, &greg1);
        }
        else
        {
            if (greg1 == 1)
            {
                tag1 = pegaString(reg1, prr1, index1, &greg1);
                fprintf(indexF, "%s;%s;%d\n", reg1, prr1, p);
            }
            else
            {
                fprintf(indexF, "%s;%s;%d\n", reg1, prr1, p);
                tag1 = pegaString(reg1, prr1, index1, &greg1);
            }
        }
    }
    return tag1;
}

int pegaStringIM(char* registro, char* prr, FILE* index, int *valor)
{
    int i;
    if (feof(index))
        return 1;
    else
    {
        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &registro[i]);
            if (feof(index))
                return 1;
        }
        while (registro[i] != ';');
        registro[i] = '\0';

        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &prr[i]);
            if (feof(index))
                return 1;
        }
        while (prr[i] != '\n');
        prr[i] = '\0';
    }
    *valor = 0;
    return 0;
}
